﻿// ***********************************************************************
// Assembly         : Delta_webControl
// Author           : YTECGJ
// Created          : 04-24-2013
//
// Last Modified By : YTECGJ
// Last Modified On : 05-27-2013
// ***********************************************************************
// <copyright file="Delta_grid.cs" company="">
//     Copyright (c) 2013  2013 . All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.UI.WebControls;
using System.Web.UI;
using Delta_webrender;
using Delta_util.Clases;
using System.Collections;
using Delta_entidad.Base;
using Delta_entidad.Atributos;
using Delta_util.Estaticos;
using System.IO;
using Delta_entidad.EntidadesControl;
using System.Data;
using System.Reflection;
using Delta_control.Base;
using System.ComponentModel;
using System.Web.Caching;
using Delta_webrender.Dynamic;
using System.Web.UI.Design;
using System.ComponentModel.Design;
using System.Drawing;

namespace Delta_webControl.DynamicData
{


    /// <summary>
    /// Componente Web Delta Grid, este componente permite la manipulación de tablas en una aplicación Web, permitiendo las operaciones de Insetar,Modificar,Eliminar,Filtrar
    /// de manera automatica, y ademas permite configuración OnLine.
    /// </summary>
    [ToolboxData("<{0}:Delta_grid runat=\"server\" TipoDato=\"\" Titulo=\"\"></{0}:Delta_grid>")]
    [ToolboxBitmap(typeof(System.Web.DynamicData.DynamicControl))]
    [Designer(typeof(PlantillaDisenio))]
    public class Delta_grid : WebControl, INamingContainer
    {
        #region Declaraciones

        /// <summary>
        /// Etiqueta que muestra el titulo del componente.
        /// </summary>
        protected global::System.Web.UI.WebControls.Literal lbllicencia = new System.Web.UI.WebControls.Literal() { ID = "lblLicencia" };
        /// <summary>
        /// Etiqueta que muestra el titulo del componente.
        /// </summary>
        protected global::System.Web.UI.WebControls.Label lbltitulo = new System.Web.UI.WebControls.Label() { ID = "lblTitulo", CssClass = "TituloModulo" };
        /// <summary>
        /// Hidden que sirve de memoria para guardar los nombres de los campos claves del GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.HiddenField HClaves = new HiddenField();
        /// <summary>
        /// Componente para realizar las llamadas asincronas.
        /// </summary>
        protected global::System.Web.UI.UpdatePanel UpdatePanel1 = new UpdatePanel() { UpdateMode = UpdatePanelUpdateMode.Conditional };
        /// <summary>
        /// Etiqueta que muestra la descripción de los errores que se producen en la ejecución.
        /// </summary>
        protected global::System.Web.UI.WebControls.Label lblError = new System.Web.UI.WebControls.Label() { ID = "lblError", CssClass = "error" };

        /// <summary>
        /// Panel principal de filtro.
        /// </summary>
        protected global::System.Web.UI.WebControls.Panel pnlContenedorFiltro = new System.Web.UI.WebControls.Panel() { ClientIDMode = ClientIDMode.Static, EnableViewState = false };
        /// <summary>
        /// Panel contenedor de los componentes que permiten aplciar filtro al GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.Panel pnlFiltro = new System.Web.UI.WebControls.Panel() { CssClass = "PanelFiltro", ClientIDMode = ClientIDMode.Static, EnableViewState = false };
        /// <summary>
        /// Literal que permite configurar el titulo del filtro.
        /// </summary>
        protected global::System.Web.UI.WebControls.Literal ltPanelFiltro = null;
        /// <summary>
        /// Hidden que guarda el estatus del filtro, es decir, si es visible u oculto.
        /// </summary>
        protected global::System.Web.UI.WebControls.HiddenField HEstatusPanel = new HiddenField() { ClientIDMode = ClientIDMode.Static };
        /// <summary>
        /// Tabla en la que se dibujan los componentes de filtros.
        /// </summary>
        protected global::System.Web.UI.WebControls.Table tbFiltro = new System.Web.UI.WebControls.Table() { ClientIDMode = ClientIDMode.Static, EnableViewState = false };
        /// <summary>
        /// Botón que se encarga de aplicar el filtro al GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.Button btnAplicarFiltro = new System.Web.UI.WebControls.Button() { Text = "Aplicar", OnClientClick = "pkMsgModal('Aplicando filtros....');" };
        /// <summary>
        /// Botón que se encarga de quitar todos los filtros aplicados al GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.Button btnLimpiaFiltro = new System.Web.UI.WebControls.Button() { Text = "Limpiar", OnClientClick = "pkMsgModal('Quitando filtros....');" };

        /// <summary>
        /// Panel que contiene los botones de acciones que usa el Delta Grid.
        /// </summary>
        protected global::System.Web.UI.WebControls.Panel pnlBarra = new System.Web.UI.WebControls.Panel() { ClientIDMode = ClientIDMode.Static };
        /// <summary>
        /// Botón que permite la inserción de nuevos registros al GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.Button btnNuevo = new System.Web.UI.WebControls.Button() { Text = "Nuevo", ID = "btnNuevo", OnClientClick = "alert('Grid no configurado'); return false;" };
        /// <summary>
        /// Componente GridView que permite mostrar la tabla de datos.
        /// </summary>
        protected global::System.Web.UI.WebControls.GridView grdRegistros = new GridView() { ID = "grdRegistros", EmptyDataText = "No hay registros para mostrar.", ShowHeaderWhenEmpty = true };

        /// <summary>
        /// Componente Hidden que permite guardar en memoria la entidad maestra del Delta Grid.
        /// </summary>
        protected global::System.Web.UI.WebControls.HiddenField HEntidadMaster = new HiddenField();

        /// <summary>
        /// Componente Hidden que permite guardar en memoria la entidad selccionada en el GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.HiddenField HEntidadActual = new HiddenField();
        /// <summary>
        /// Componente Hidden que permite guardar el estatus que indica si se permite editar los registros del GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.HiddenField HEdicion = new HiddenField();
        /// <summary>
        /// Componente Hidden que permite guardar el estatus que indica si se permite eliminar los registros del GridView.
        /// </summary>
        protected global::System.Web.UI.WebControls.HiddenField HEliminar = new HiddenField();

        /// <summary>
        /// Variable que indica si se debe borrar los datos de la entidad actual y la entidad master en el Load de la página.
        /// </summary>
        protected internal bool limpiarEntidades = true;
        /// <summary>
        /// Guarda la URL donde se encuentra el cargador de paginas, este cargador es importante ya que de el depende la visualización de varias paginas administrativas.
        /// </summary>
        protected string ruta_cargador = null;
        /// <summary>
        /// Permite guardar y recuperar el estado del Delta Grid.
        /// </summary>
        private StateDeltaGrid EdoControl = new StateDeltaGrid();
        /// <summary>
        /// Variable que indica si el Delta Grid permite agregar registros, esta variabla depende del valor de memoria.
        /// </summary>
        private bool? _PermitirAgregar = null;
        /// <summary>
        /// Variable que indica el tipo de dato del Delta Grid.
        /// </summary>
        private Type _tipo_dato;
        /// <summary>
        /// Clase que se encarga de dar formato a las columnas del GridView.
        /// </summary>
        protected FormatoGrid ctrlGrid = new FormatoGrid();
        /// <summary>
        /// Indica el componente Delta Grid del cual depende este Delta Grid.
        /// </summary>
        protected Delta_grid _padre = null;
        /// <summary>
        /// Guarda la clave del Tipo General, este valor es necesario cuando se usa Delta Grid dinamico y de consulta.
        /// </summary>
        protected int IdTipoGral = 0;
        /// <summary>
        /// Tabla que se encarga de guardar los campos de la entidad que permiten filtros.
        /// </summary>
        protected Hashtable camposFiltrosTb = new Hashtable();
        /// <summary>
        /// Guarda todos los Delta Grid hijos de este componente.
        /// </summary>
        protected List<Delta_grid> ListaEnlaces = new List<Delta_grid>();


        /// <summary>
        /// Variable que guarda la cadena encriptada del ID del componente
        /// </summary>
        protected string ID_Enc = string.Empty;

        /// <summary>
        /// Variable que guarda la cadena encriptada de la variable parametros def en formato JSON
        /// </summary>
        protected string Parametros_Enc = string.Empty;
        #endregion

        #region Delegados y eventos
        /// <summary>
        /// Delegado para realizar operaciones extras antes que se elimine un registro.
        /// </summary>
        /// <param name="sender">Componente GridView del cual se elimina el registro</param>
        /// <param name="e">La <see cref="GridViewDeleteEventArgs"/> instancia que contiene los datos del evento.</param>
        /// <param name="entidadActual">Datos de la entidad a eliminar.</param>
        /// <param name="entidadPadre">Datos de la entidad padre del Delta Grid.</param>
        public delegate void del_Grid_Eliminar(object sender, GridViewDeleteEventArgs e, TipoBase entidadActual, TipoBase entidadPadre);
        /// <summary>
        /// Delegado para realizar operaciones extras despues que se elimina un registro.
        /// </summary>
        /// <param name="sender">Componente GridView del cual se elimina el registro</param>
        /// <param name="ev">La <see cref="GridViewDeleteEventArgs"/> instancia que contiene los datos del evento.</param>
        public delegate void del_Grid_DataBound(object sender, GridViewRowEventArgs ev);

        /// <summary>
        /// Delegado para realizar las operaciones extras al seleccionar una fila del GridView.
        /// </summary>
        /// <param name="sender">El control Gridview.</param>
        /// <param name="e">Instancia de los datos del evento.</param>        
        public delegate void del_Grid_SelectedIndexChanged(object sender, EventArgs e);
        /// <summary>
        /// Evento que sucede antes de eliminar un registro del GridView.
        /// </summary>
        public event del_Grid_Eliminar Antes_Eliminar_Grid;
        /// <summary>
        /// Evento que sucede despues de eliminar un registro del GridView.
        /// </summary>
        public event del_Grid_Eliminar Despues_Eliminar_Grid;
        /// <summary>
        /// Evento que sucede cuando se inserta un nuevo registro al GridView.
        /// </summary>
        public event del_Grid_DataBound CreacionFila;

        /// <summary>
        /// Evento que sucede cuando se cambia la seleccion de la fila del GridView.
        /// </summary>
        public event del_Grid_SelectedIndexChanged SeleccionFila;
        #endregion

        #region CONSTRUCTOR

        /// <summary>
        /// Sucede al iniciar la creación del componente <see cref="E:System.Web.UI.Control.Init" />.
        /// </summary>
        /// <param name="e">Objeto <see cref="T:System.EventArgs" /> que contiene los datos del evento.</param>
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            Page.RegisterRequiresControlState(this);
        }

        /// <summary>
        /// Guarda los cambios de estado de un control de servidor que se hayan producido desde el momento en que se devolvieron al servidor los datos de la página.
        /// </summary>
        /// <returns>Devuelve el estado actual del control de servidor.Si no hay ningún estado asociado al método, este método devuelve null.</returns>
        protected override object SaveControlState()
        {

            object obj = base.SaveControlState();

            if (obj != null)
            {
                return new Pair(obj, EdoControl);
            }
            else
            {
                return (EdoControl);
            }

        }

        /// <summary>
        /// Se encarga de cargar el estado del control del servidor.
        /// </summary>
        /// <param name="state">Datos del estado.</param>
        protected override void LoadControlState(object state)
        {
            if (state != null)
            {
                Pair p = state as Pair;
                if (p != null)
                {
                    base.LoadControlState(p.First);
                    EdoControl = (StateDeltaGrid)p.Second;
                }
                else
                {
                    if (state is StateDeltaGrid)
                    {
                        EdoControl = (StateDeltaGrid)state;
                    }
                    else
                    {
                        base.LoadControlState(state);
                    }
                }
            }
        }
        /// <summary>
        /// Inicializa una nueva instancia de la clase <see cref="Delta_grid"/>.
        /// </summary>
        public Delta_grid()
        {
            this.Load += new EventHandler(Delta_grid_Load);


            if (System.Diagnostics.Process.GetCurrentProcess().ProcessName.ToUpper() != "DEVENV")
                CrearControles();

        }


        /// <summary>
        /// Lo llama el marco de trabajo de las páginas ASP.NET para indicar a los controles de servidor que utilizan la implementación basada en la composición que creen los controles secundarios que contengan como forma de preparar la devolución o representación de los datos.
        /// </summary>
        protected override void CreateChildControls()
        {

            if (string.IsNullOrWhiteSpace(grdRegistros.SelectedRowStyle.CssClass))
                grdRegistros.SelectedRowStyle.CssClass = "FilaGridSeleccionada";
            pnlContenedorFiltro.ID = this.ID + "_ContenedorFiltro";
            tbFiltro.ID = this.ID + "_tbFiltro";
            btnLimpiaFiltro.ID = this.ID_COMPONENTE + "_btnLimpiarFiltro";
            btnAplicarFiltro.ID = this.ID_COMPONENTE + "_btnAplicarFiltro";
            HEstatusPanel.ID = this.ID_COMPONENTE + "_hEstatusFiltro";
            pnlFiltro.ID = this.ID_COMPONENTE + "_pnlFiltro";
            pnlBarra.ID = this.ID + "_pnlBarra";
            ltPanelFiltro.Text = string.Format(ltPanelFiltro.Text, this.ID_COMPONENTE);
            btnAplicarFiltro.Attributes.Add("tag", "delta_grid");
            btnLimpiaFiltro.Attributes.Add("tag", "delta_grid");
            this.grdRegistros.Attributes.Add("tag", "delta_grid");
            btnNuevo.Attributes.Add("tag", "delta_grid");

        }
        /// <summary>
        /// Se encarga de configurar el control Delta Grid, creando los filtros, y demas componentes.
        /// </summary>
        protected void CrearControles()
        {
            try
            {

                ruta_cargador = System.Configuration.ConfigurationManager.AppSettings["rutaCargador"];


                //Se configura el panel del filtro

                tbFiltro.Rows.Add(TablaUI.CrearFIla(this.ID + "_fila_controles"));
                tbFiltro.Rows.Add(TablaUI.CrearFIla(this.ID + "_fila_botones"));
                ltPanelFiltro = new Literal() { Text = "<div class='TituloPanelFiltro' id='titFiltro_{0}'>Filtro de datos</div>" };
                btnAplicarFiltro.Click += btnFiltro_Click;
                btnLimpiaFiltro.Click += new EventHandler(btnLimpiaFiltro_Click);

                tbFiltro.Rows[1].Cells.Add(TablaUI.CrearCelda(this.ID_COMPONENTE + "_celda_boton_aplicar", btnAplicarFiltro));
                tbFiltro.Rows[1].Cells.Add(TablaUI.CrearCelda(this.ID_COMPONENTE + "_celda_boton_limpiar", btnLimpiaFiltro));
                pnlFiltro.Controls.Add(HEstatusPanel);
                pnlFiltro.Controls.Add(tbFiltro);

                pnlBarra.Controls.Add(btnNuevo);
                pnlBarra.Controls.Add(lbllicencia);
                pnlBarra.Controls.Add(grdRegistros);

                UpdatePanel1.ContentTemplateContainer.Controls.Add(lblError);
                UpdatePanel1.ContentTemplateContainer.Controls.Add(pnlContenedorFiltro);


                UpdatePanel1.ContentTemplateContainer.Controls.Add(pnlBarra);
                UpdatePanel1.ContentTemplateContainer.Controls.Add(HEdicion);
                UpdatePanel1.ContentTemplateContainer.Controls.Add(HEliminar);
                UpdatePanel1.ContentTemplateContainer.Controls.Add(HEntidadMaster);
                UpdatePanel1.ContentTemplateContainer.Controls.Add(HEntidadActual);
                AsyncPostBackTrigger trgNuevo = new AsyncPostBackTrigger();
                AsyncPostBackTrigger trgAplicarFiltro = new AsyncPostBackTrigger();
                AsyncPostBackTrigger trgLimpiarFiltro = new AsyncPostBackTrigger();
                AsyncPostBackTrigger trgEliminarFila = new AsyncPostBackTrigger();

                trgEliminarFila.ControlID = grdRegistros.ID;
                trgEliminarFila.EventName = "RowDeleting";

                trgNuevo.ControlID = btnNuevo.ID;
                trgNuevo.EventName = "Click";

                trgAplicarFiltro.ControlID = btnAplicarFiltro.ID;
                trgAplicarFiltro.EventName = "Click";
                trgLimpiarFiltro.ControlID = btnLimpiaFiltro.ID;
                trgLimpiarFiltro.EventName = "Click";

                UpdatePanel1.Triggers.Add(trgNuevo);

                //Se dibujan los controles
                this.Controls.Add(lbltitulo);
                this.Controls.Add(HClaves);

                this.Controls.Add(UpdatePanel1);

                //Se enlazan los eventos       
                this.btnNuevo.Click += btnNuevo_Click;

                this.grdRegistros.RowDataBound += grdRegistros_RowDataBound;
                this.grdRegistros.RowDeleting += grdRegistros_RowDeleting;
                this.grdRegistros.RowEditing += Grid_RowEditing;
                this.grdRegistros.RowCancelingEdit += Grid_RowCancelingEdit;
                this.grdRegistros.RowUpdating += Grid_RowUpdating;
                this.grdRegistros.SelectedIndexChanged += grdRegistros_SelectedIndexChanged;
                this.grdRegistros.PageIndexChanging += grdRegistros_PageIndexChanging;


            }
            catch (Exception ex)
            {
                throw new Exception(ex.StackTrace);
            }
        }


        /// <summary>
        /// Handle que sucede cuando se carga completamente la pagina
        /// </summary>
        /// <param name="sender">Objeto donde se realiza la carga.</param>
        /// <param name="e">La<see cref="EventArgs"/> instancia que contiene los datos del evento.</param>
        protected void Delta_grid_Load(object sender, EventArgs e)
        {

            if (ruta_cargador != null)
                ruta_cargador = ruta_cargador.Replace("~/", Utilerias.ObtenerHttpServer(this.Page));



            if (Page != null && !Page.IsPostBack)
            {
                DatoFiltroPanel = null;
                DatoFiltro = null;
                ControlDato = null;
                TablaControles = null;
                ListaCtrl = null;
                ParametrosDef = null;
                if (limpiarEntidades)
                {
                    EntidadActual = null;
                    EntidadMaster = null;
                }
                //EstatusUI = null;
            }


            ConfigurarDatos();

            bool aplicarConfiguracionWeb = ConfiguracionUser != null && ConfiguracionUser.configuracion_web;

            if (aplicarConfiguracionWeb && !string.IsNullOrWhiteSpace(ConfiguracionUser.titulo))
                lbltitulo.Text = ConfiguracionUser.titulo;

        }



        #endregion

        #region Propiedades privadas
        
        /// <summary>
        /// Esta propiedad se usa cuando se realiza el enlace entre dos Delta Grid , en esta lista se almacenan los valores de las claves configuradas en el vinculo, 
        /// los valores se toman del Delta Grid padre y se almacenan en el Delta Grid hijo.
        /// </summary>
        /// <value>IDictionary<string,objec> que contiene los valores y campos default.</value>
        protected internal IDictionary<string, object> ParametrosDef
        {
            get
            {
                if (Page.Cache[Constantes.claveDeltaParametrosDef + ID_COMPONENTE] == null)
                    return null;
                else
                    return (IDictionary<string, object>)Page.Cache[Constantes.claveDeltaParametrosDef + ID_COMPONENTE];
            }
            set
            {
                if (value == null)
                    Page.Cache.Remove(Constantes.claveDeltaParametrosDef + ID_COMPONENTE);
                else
                    Page.Cache[Constantes.claveDeltaParametrosDef + ID_COMPONENTE] = value;
            }
        }
        /// <summary>
        /// Esta tabla permite guardar los valores de los diferentes estatus que maneja el Delta Grid, estos estatus se guardan en la memoria de la página.
        /// </summary>
        /// <value>HashTable con los estatus y su valor logico.</value>
        protected internal Hashtable EstatusUI
        {
            get
            {

                if (EdoControl == null)
                    EdoControl = new StateDeltaGrid();

                return EdoControl.EstatusUI;
            }
            set
            {
                EdoControl.EstatusUI = value;
            }
        }
        /// <summary>
        /// Obtiene o establece la clase control que se encarga de interpretar las solicitudes de Delta Grid con los datos en la BD.
        /// </summary>
        /// <value>Control generico representado como dinamico.</value>
        protected internal dynamic ControlDato
        {
            get
            {
                if (Page != null)
                {
                    object ctrl = Page.Cache[Constantes.claveControl + this.ID_COMPONENTE];
                    if (ctrl == null)
                    {
                        //Se crea la instancia del control                    
                        ctrl = Comun.CrearInstanciaGenerico(typeof(ControlBase<>), _tipo_dato);
                        (ctrl as dynamic).CargarConfiguracionUser(null, null);
                        this.EdoControl.DatosConfiguracionDinamica = (ctrl as dynamic).InformacionUsers;
                        Page.Cache[Constantes.claveControl + this.ID_COMPONENTE] = ctrl;
                    }
                    return ctrl;
                }
                else
                    return null;
            }
            set
            {

                if (value == null)
                    Page.Cache.Remove(Constantes.claveControl + this.ID_COMPONENTE);
                else
                {
                    Page.Cache[Constantes.claveControl + this.ID_COMPONENTE] = value;
                }

            }
        }
        /// <summary>
        /// Obtiene la ruta del editor de datos del Delta Grid, esta propiedad depende del cargador de paginas, si el cargador no esta configurado correctamente, entonces el editor no se podrá visualizar.
        /// </summary>
        /// <value>La ruta del editor.</value>
        protected string RutaEditor
        {
            get
            {
                if (ruta_cargador == null)
                    return null;
                else
                    return ruta_cargador + "?url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmEditorItem", ConfigProy.claveKey);
            }
        }
        /// <summary>
        /// Obtiene la ruta del importador de datos EXCEL del Delta Grid, esta propiedad depende del cargador de paginas, si el cargador no esta configurado correctamente, entonces el importador no se podrá visualizar.
        /// </summary>
        /// <value>La ruta del importar.</value>
        protected string RutaImportar
        {
            get
            {
                if (ruta_cargador == null)
                    return null;
                else
                    return ruta_cargador + "?url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmImportarExcel", ConfigProy.claveKey);
            }
        }
        /// <summary>
        /// Obtien o establece los datos en memoria de los datos recibidos como parametro para filtrar la tabla del Delta Grid.
        /// </summary>
        /// <value>Entidad que herede TipoBase, que contiene los datos de filtro</value>
        protected internal TipoBase DatoFiltro
        {
            get
            {
                if (Page.Cache[Constantes.claveDeltaEntFiltro + ID_COMPONENTE] == null)
                    return null;
                else
                    return (TipoBase)Page.Cache[Constantes.claveDeltaEntFiltro + ID_COMPONENTE];
            }
            set
            {
                if (value == null)
                    Page.Cache.Remove(Constantes.claveDeltaEntFiltro + ID_COMPONENTE);
                else
                    Page.Cache[Constantes.claveDeltaEntFiltro + ID_COMPONENTE] = value;
            }
        }
        /// <summary>
        /// Obtiene un valor que indica si se aplica la configuración indicada desde la WEB o se toma la configuración indicada en la entidad.
        /// </summary>
        /// <value><c>true</c> si se aplica la configuracion web, en caso contratio <c>false</c>.</value>
        protected internal bool AplicarConfiguracionWEB
        {
            get
            {
                return Page != null && ConfiguracionUser != null && ConfiguracionUser.configuracion_web;
            }
        }
        /// <summary>
        /// Obtiene el valor que indica si se puede editar los registros del Delta Grid, este valor depende de que el Delta Grid permite la edición de registros.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        protected internal bool EdicionMem
        {
            get
            {
                bool aplicarConfiguracionWeb = AplicarConfiguracionWEB;

                return (Utilerias.DefinicionEstatusUI(EstatusUI[Enumerados.TIPO_OPERACION_GRID.ACTUALIZAR]) &&
                    (aplicarConfiguracionWeb ? ConfiguracionUser.operaciones.Exists((op) => { return op.id_operacion == (Int16)Enumerados.TIPO_OPERACION_GRID.ACTUALIZAR; })
                    : AtributosEntidad.operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.ACTUALIZAR)));

            }

        }
        /// <summary>
        /// Obtiene el valor que indica si se visualiza el panel de filtro, este permiso depende de que el Delta Grid permite la operación de filtro.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario  <c>false</c>.</value>
        protected internal bool PermitirFiltros
        {
            get
            {
                bool aplicarConfiguracionWeb = ConfiguracionUser != null && ConfiguracionUser.configuracion_web;
                if (aplicarConfiguracionWeb)
                    return Utilerias.DefinicionEstatusUI(EstatusUI[Enumerados.TIPO_OPERACION_GRID.FILTRO]) && ConfiguracionUser.operaciones.Exists((op) => { return op.id_operacion == (Int16)Enumerados.TIPO_OPERACION_GRID.FILTRO; });
                else
                    return Utilerias.DefinicionEstatusUI(EstatusUI[Enumerados.TIPO_OPERACION_GRID.FILTRO]) && AtributosEntidad.operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.FILTRO);

            }

        }
        /// <summary>
        /// Obtiene el valor que indica si se permite eliminar registros del Delta Grid, este permiso depende de que el Delta Grid permita la operación Eliminar.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario  <c>false</c>.</value>
        protected internal bool EliminarMem
        {
            get
            {
                bool aplicarConfiguracionWeb = ConfiguracionUser != null && ConfiguracionUser.configuracion_web;

                return (Utilerias.DefinicionEstatusUI(EstatusUI[Enumerados.TIPO_OPERACION_GRID.ELIMINAR]) &&
                    (aplicarConfiguracionWeb ? ConfiguracionUser.operaciones.Exists((op) => { return op.id_operacion == (Int16)Enumerados.TIPO_OPERACION_GRID.ELIMINAR; })
                    : AtributosEntidad.operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.ELIMINAR)));

            }

        }
        /// <summary>
        /// Obtiene o establece en memoria la configuración de las columnas, ya sea las dinamicas o las estaticas.
        /// </summary>
        /// <value>TablaUI que contiene la configuración de las columnas del GridView.</value>
        protected internal TablaUI TablaControles
        {

            get
            {
                if (Page.Cache[Constantes.claveDeltaEntTablaUI + ID_COMPONENTE] == null)
                    return null;
                else
                    return (TablaUI)Page.Cache[Constantes.claveDeltaEntTablaUI + ID_COMPONENTE];
            }
            set
            {
                if (value == null)
                    Page.Cache.Remove(Constantes.claveDeltaEntTablaUI + ID_COMPONENTE);
                else
                    Page.Cache[Constantes.claveDeltaEntTablaUI + ID_COMPONENTE] = value;
            }
        }
        /// <summary>
        /// Obtiene o establece en memoria los valores de los filtros aplicados mediante el panel de filtro.
        /// </summary>
        /// <value>Entidad que hereda TipoBase la cual guarda los datos.</value>
        internal TipoBase DatoFiltroPanel
        {
            get
            {
                if (Page.Cache[Constantes.claveDeltaEntFiltroPanel + ID_COMPONENTE] == null)
                    return null;
                else
                    return (TipoBase)Page.Cache[Constantes.claveDeltaEntFiltroPanel + ID_COMPONENTE];
            }
            set
            {
                if (value == null)
                    Page.Cache.Remove(Constantes.claveDeltaEntFiltroPanel + ID_COMPONENTE);
                else
                    Page.Cache[Constantes.claveDeltaEntFiltroPanel + ID_COMPONENTE] = value;
            }
        }
        /// <summary>
        /// Obtiene o establece el valor que indica si la tabla es dinamica, es decir, es una tabla que no existe fisicamente en la base de datos, 
        /// todas las columnas son dinamicas.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        protected internal bool EsDinamico
        {
            get
            {
                if (ViewState[Constantes.claveDeltaDinamico + ID_COMPONENTE] == null)
                    return false;
                else
                    return (bool)ViewState[Constantes.claveDeltaDinamico + ID_COMPONENTE];
            }
            set
            {
                ViewState[Constantes.claveDeltaDinamico + ID_COMPONENTE] = value;
            }
        }
        /// <summary>
        /// Obtiene un valor que indica si la tabla que se muestra es de consulta, es decir, que ejecuta un procedimiento almacenado y muestra los datos obtenidos,
        /// cuando un Delta Grid es de consulta, no se permiten las operaciones de Insertar,Eliminar,Editar,Importar,Editar Excel.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        protected bool EsConsulta
        {
            get
            {

                return TipoBaseControl != null && typeof(Delta_entidad.EntidadesControl.Tabla_consulta) == TipoBaseControl;
            }
        }
        /// <summary>
        /// Obtiene el atributo AttEntidad del tipo configurado en el Delta Grid.
        /// </summary>
        /// <value>Clase AttEntidad que contiene la configuración del Delta Grid.</value>
        protected AttEntidad AtributosEntidad
        {
            get
            {

                AttEntidad dentidad = Comun.ObtenerAtributoEntidad<AttEntidad>(_tipo_dato);
                if (dentidad != null)
                    return dentidad;
                else
                    return new AttEntidad(null, null, false, 0);
            }
        }

        /// <summary>
        /// Obtiene de la memoria la configuración user del tipo configurado en el Delta Grid, esta configuración se obtiene de la BD.
        /// </summary>
        /// <value>Clase Cat_tipo_gral que contiene la configuración dinamca de los campos.</value>
        protected internal Cat_tipo_gral ConfiguracionUser
        {
            get
            {
                if (EdoControl != null)
                    return EdoControl.DatosConfiguracionDinamica;
                else
                    return null;
                //if (ControlDato != null)
                //    return ControlDato.InformacionUsers;
                //else
                //    return null;
            }
        }
        #endregion

        #region Propiedades


        /// <summary>
        /// Obtiene el componente GridView que se usa para representar los datos del Delta Grid.
        /// </summary>
        /// <value>Componente GridView</value>
        public GridView TablaDatos
        {
            get
            {
                return this.grdRegistros;
            }
        }
        /// <summary>
        /// Obtiene el nombre unico del componente Delta Grid.
        /// </summary>
        /// <value>The I d_ COMPONENTE.</value>
        public string ID_COMPONENTE
        {
            get
            {
                //string dif = null;
                //if (Page == null)
                //    dif = Utilerias.HashMD5(this.ID);
                //else
                //    dif = Utilerias.HashMD5(Page.GetType().FullName);

                return this.ID;
            }
        }
        /// <summary>
        /// Obtiene o establece los datos de la entidad seleccionada en el Delta Grid, este dato tiene valor solo cuando se permite la operación de seleccionar en el control.
        /// </summary>
        /// <value>Entidad TipoBase que contiene los datos de la fila actualmente seleccionada.</value>
        public TipoBase EntidadActual
        {

            get
            {
                if (ViewState[Constantes.claveDeltaEntidadActual + ID_COMPONENTE] == null)
                    return null;
                else
                    return (TipoBase)ViewState[Constantes.claveDeltaEntidadActual + ID_COMPONENTE];
            }
            set
            {

                if (value == null)
                    ViewState.Remove(Constantes.claveDeltaEntidadActual + ID_COMPONENTE);
                else
                    ViewState[Constantes.claveDeltaEntidadActual + ID_COMPONENTE] = value;
            }



        }
        /// <summary>
        /// Obtiene el tipo de dato de la entidad configurada para el Delta Grid.
        /// </summary>
        /// <value>Tipo de dato</value>
        public Type TipoBaseControl
        {
            get
            {
                if (ControlDato != null)
                {
                    return (Type)ControlDato.TipoEntidadBase;
                }
                else
                    return _tipo_dato;


            }
        }
        /// <summary>
        /// Obtiene o establece el nombre del procedimiento almacenado a ejecutar para rellenar la lista del Delta Grid, esta propiedad solo tiene efecto cuando se configura un 
        /// Delta Grid de consulta.
        /// </summary>
        /// <value>Nombre del procedimiento a ejecutar.</value>
        public string Query_Ejecutar { get; set; }
        /// <summary>
        /// Obtiene o establece la clave del tipo de tabla, esta clave se puede consultar de los tipos dinamicos configurados, esta propiedad se debe configurar 
        /// cuando se usa tablas dinamicas.
        /// </summary>
        /// <value>Clave del tipo general de la tabla</value>
        public int ClaveTipoTabla
        {
            get { return IdTipoGral; }
            set { IdTipoGral = value; }
        }
        /// <summary>
        /// Obtiene o establece el listado que contiene la clase control del Delta Grid, esta propiedad tiene valor cuando se ejecuta el metodo ObtenerVarios de la clase control.
        /// </summary>
        /// <value>DataSource actual del GridView, representado como dynamic.</value>
        public dynamic ListaCtrl
        {
            get
            {
                if (Page.Cache[Constantes.claveDeltaListadoEnt + ID_COMPONENTE] == null)
                    return null;
                else
                    return (object)Page.Cache[Constantes.claveDeltaListadoEnt + ID_COMPONENTE];
            }
            set
            {
                if (value == null)
                    Page.Cache.Remove(Constantes.claveDeltaListadoEnt + ID_COMPONENTE);
                else
                    Page.Cache[Constantes.claveDeltaListadoEnt + ID_COMPONENTE] = value;
            }
        }

        /// <summary>
        /// Obtiene o establece el valor que indica si se muestra el icono de edición en el Delta Grid.  Debe tener en cuenta que este permiso depende de que el Delta Grid permita la operación Actualizar.
        /// Para que esta propiedad tenga efecto en el grid, debe ejecutar el metodo RecargarGrid
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool PermitirEdicion
        {
            get
            {

                return EdicionMem;

            }
            set
            {
                EstatusUI[Enumerados.TIPO_OPERACION_GRID.ACTUALIZAR] = value;

            }
        }
        /// <summary>
        /// Obtiene o establece el valor que indica si se debe permitir importar datos de un archvo excel en el Delta Grid.  
        /// Debe tener en cuenta que este permiso depende de que el Delta Grid permita la operación Importar.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool PermitirImportar
        {
            get
            {
              return false;

            }
            set
            {
                EstatusUI[Enumerados.TIPO_OPERACION_GRID.IMPORTAR] = false;
                
            }
        }
        /// <summary>
        /// Obtiene o establece el valor que indica si se debe exportar los datos del Delta Grid a un archivo excel para su edición offline.  Debe tener en cuenta que este permiso depende de que el Delta Grid permita la operación EditarExcel.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool PermitirEditarExcel
        {
            get
            {
              return false;

            }
            set
            {
                EstatusUI[Enumerados.TIPO_OPERACION_GRID.EDITAR_EXCEL] = false;
                
            }
        }
        /// <summary>
        /// Obtiene o establece el valor que indica si se debe permitir insertar nuevos registros en el Delta Grid. Debe tener en cuenta que este permiso 
        /// depende de que el Delta Grid permita la operación Insertar.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool PermitirAgregar
        {
            get
            {
                return this.btnNuevo.Enabled;

            }
            set
            {
                EstatusUI[Enumerados.TIPO_OPERACION_GRID.INSERTAR] = value;
                ConfigurarUI();

            }
        }
        /// <summary>
        /// Obtiene el valor que indica si se permite seleccionar filas de un Delta Grid, se recomienda usar este permiso cuando se tenga enlazados dos Delta Grid . 
        /// Debe tener en cuenta que este permiso depende de que el Delta Grid permita la operación Seleccionar.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool PermiteSeleccionar
        {
            get
            {
                bool aplicarConfiguracionWeb = ConfiguracionUser != null && ConfiguracionUser.configuracion_web;

                return (Utilerias.DefinicionEstatusUI(EstatusUI[Enumerados.TIPO_OPERACION_GRID.SELECCIONAR]) &&
                    (aplicarConfiguracionWeb ? ConfiguracionUser.operaciones.Exists((op) => { return op.id_operacion == (Int16)Enumerados.TIPO_OPERACION_GRID.SELECCIONAR; })
                    : AtributosEntidad.operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.SELECCIONAR)));

            }

        }
        /// <summary>
        /// Obtiene o establece el valor que indica si se permite eliminar registros del Delta Grid.Debe tener en cuenta que este permiso depende 
        /// de que el Delta Grid permita la operación Eliminar.
        /// Para que esta propiedad tenga efecto en el grid, debe ejecutar el metodo RecargarGrid
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool PermitirEliminar
        {
            get
            {

                return EliminarMem;

            }
            set
            {
                EstatusUI[Enumerados.TIPO_OPERACION_GRID.ELIMINAR] = value;

            }
        }

        #endregion

        #region Propiedades externas


        /// <summary>
        /// Obtiene o establece el TAG del Delta Grid.
        /// </summary>
        /// <value>Tag.</value>
        public string Tag
        {
            get
            {
                string val = (string)ViewState[Constantes.claveTagDeltaGrid];
                if (string.IsNullOrWhiteSpace(val))
                    val = Constantes.claveTagEstatusGlobales;

                return val;
            }
            set
            {

                ViewState[Constantes.claveTagDeltaGrid] = value;
            }
        }
        /// <summary>
        /// Obtiene o establece el texto de error a mostrar en el Delta Grid.
        /// </summary>
        /// <value>Descripción del error.</value>
        public string Error
        {
            get { return lblError.Text; }
            set { lblError.Text = value; }
        }

        /// <summary>
        /// Obtiene o establece los parametros que se quieren aplicar a la tabla de datos, esta lista se usa cada vez que se obtienen los datos de la tabla.
        /// </summary>
        /// <value>IDictionary de los valores</value>
        public Dictionary<string, object> ParametrosFiltroLista
        {
            get
            {
                return EdoControl.ParametrosConsultaGrid;
            }
            set { EdoControl.ParametrosConsultaGrid = value; }
        }
        /// <summary>
        /// Obtiene o establece la entidad seleccionada en el Delta Grid padre, esta propiedad contiene valor solo si el Delta Grid es hijo.
        /// </summary>
        /// <value>Clase que hereda TipoBase.</value>
        public TipoBase EntidadMaster
        {

            get
            {
                if (ViewState[Constantes.claveDeltaEntidadMaster + ID_COMPONENTE] == null)
                    return null;
                else
                    return (TipoBase)ViewState[Constantes.claveDeltaEntidadMaster + ID_COMPONENTE];
            }
            set
            {
                try
                {
                    if (value == null)
                        ViewState.Remove(Constantes.claveDeltaEntidadMaster + ID_COMPONENTE);
                    else
                        ViewState[Constantes.claveDeltaEntidadMaster + ID_COMPONENTE] = value;
                    if (!limpiarEntidades)
                    {
                        RellenarDefault();
                        MostrarGrid(true);
                        RellenarDefault();
                        ActualizarListadoFiltros();
                        this.btnNuevo.OnClientClick = "MostrarEdicion_" + this.ID + "(false,'" + Utilerias.Encriptar(ID, ConfigProy.claveKey) + "','','" + Utilerias.Encriptar(Utilerias.SerializarJSon(ParametrosDef), ConfigProy.claveKey) + "'); return false;";
                    }
                }
                catch (Exception ex)
                {
                    lblError.Text = "No se logro establecer la entidad master=" + Utilerias.getMsgError(ex);
                }
            }


        }
        /// <summary>
        /// Obtiene o establece los nombres de los campos usados para enlazar dos Delta Grid, se configuran en el Delta Grid padre y son separados por coma.
        /// </summary>
        /// <value>The claves enlace.</value>
        public string ClavesEnlace
        {
            get { return this.HClaves.Value; }
            set
            {
                this.HClaves.Value = value;

            }
        }
        /// <summary>
        /// Obtiene o establece si se debe visualizar el panel de filtro de datos. Debe tener en cuenta que este permiso depende de que el Delta Grid permita la operación Filtro.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool MostrarFiltro
        {
            get
            {
                return PermitirFiltros;
            }
            set
            {
                EstatusUI[Enumerados.TIPO_OPERACION_GRID.FILTRO] = value;
            }
        }
        /// <summary>
        /// Obtiene o establece si al filtrar los datos usando el panel de filtro, se debe obtener la lista de la base de datos (true) o se debe tomar de la memoria (false).
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool ActualizarAlFiltrar
        {
            get
            {
                if (ViewState[Constantes.claveActualizarFiltrar + ID_COMPONENTE] == null)
                    return true;
                else
                    return (bool)ViewState[Constantes.claveActualizarFiltrar + ID_COMPONENTE];
            }
            set
            {
                ViewState[Constantes.claveActualizarFiltrar + ID_COMPONENTE] = value;
            }
        }
        /// <summary>
        /// Obtiene o establece si se debe mostrar el menu contextual del Delta Grid, el cual cuenta con opciones de configuración de los campos del Delta Grid.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool VisualizarMenuContextual
        {
            get
            {
                if (ViewState[Constantes.claveVisualizarMC + ID_COMPONENTE] == null)
                    return true;
                else
                    return (bool)ViewState[Constantes.claveVisualizarMC + ID_COMPONENTE];
            }
            set
            {
                ViewState[Constantes.claveVisualizarMC + ID_COMPONENTE] = value;
            }
        }
        /// <summary>
        /// Obtiene o establece la referencia usada para diferencia tablas dinamicas, este dato puede ser un folio de alguna tabla padre, esta propiedad se debe configurar cuando se usa tablas dinamicas
        /// </summary>
        /// <value>The referencia.</value>
        public string Referencia { get; set; }
        /// <summary>
        /// Obtiene o establece el folio de la tabla dinamica, este folio se obtiene de la tabla Tablas_gral de la BD, esta propiedad se debe configurar cuando se usa tablas dinamicas.
        /// </summary>
        /// <value>The folio tabla gral.</value>
        public int FolioTablaGral
        { get; set; }
        /// <summary>
        /// Obtiene o establece si el componente Delta Grid esta activo.
        /// </summary>
        /// <value><c>true</c> si aplica, en caso contrario <c>false</c>.</value>
        public bool Activo
        {

            get { return pnlBarra.Enabled; }

            set { pnlBarra.Enabled = value; }
        }
        /// <summary>
        /// Obtiene o establece el titulo que se muestra en el Delta Grid.
        /// </summary>
        /// <value>The titulo.</value>
        public string Titulo
        {
            get
            {
                return this.lbltitulo.Text;
            }
            set { this.lbltitulo.Text = value; }
        }
        /// <summary>
        /// Obtiene o establece el tipo de dato a representar en el Delta Grid, el tipo de dato se representa en cadena, escibiendo el nombre completo del tipo de dato, por el momento los tipos de entidades permitidas son aquellas que heredan la clase TipoBase.
        /// </summary>
        /// <value>The tipo dato.</value>
        public string TipoDato
        {
            get
            {

                if (_tipo_dato == null)
                    return "";
                else
                    return this._tipo_dato.Name;
            }
            set
            {
                try
                {

                    this._tipo_dato = Comun.CrearInstancia(value).GetType();
                    EsDinamico = _tipo_dato == typeof(TablasGral);

                }
                catch { }
            }
        }
        /// <summary>
        /// Obtiene o establece el control Delta Grid padre, esta propiedad contiene valor cuando se enlaza dos Delta Grid.
        /// </summary>
        /// <value>El Delta Grid padre.</value>
        public Delta_grid DeltaPadre
        {
            get { return this._padre; }
            set
            {
                this._padre = null;
                if (value != null)
                {
                    AsyncPostBackTrigger trg = new AsyncPostBackTrigger();
                    AsyncPostBackTrigger trgEliminar = new AsyncPostBackTrigger();
                    trg.ControlID = value.TablaDatos.ID;
                    trg.EventName = "SelectedIndexChanged";
                    trgEliminar.ControlID = value.TablaDatos.ID;
                    trgEliminar.EventName = "RowDeleting";
                    this.UPanel.Triggers.Add(trg);
                    this.UPanel.Triggers.Add(trgEliminar);
                    this._padre = value;
                    value.AgregarEnlace(this);

                }
            }
        }
        /// <summary>
        /// Obtiene el Update Panel que se usa Delta Grid para realizar operaciones asincronas.
        /// </summary>
        /// <value>The U panel.</value>
        public UpdatePanel UPanel { get { return this.UpdatePanel1; } }
        #endregion

        #region Handlers

        /// <summary>
        /// Handler que se ejecuta cuando se reestablece el panel de filtro.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="EventArgs"/> instancia de la clase con los datos del evento.</param>
        protected void btnLimpiaFiltro_Click(object sender, EventArgs e)
        {
            try
            {

                DatoFiltroPanel = null;
                ControlDato.CrearEntidad();
                TablaControles.LimpiarTabla(tbFiltro, ControlDato.Dato, "wfiltro");
                MostrarGrid(ActualizarAlFiltrar);
            }
            catch { }
            finally { btnLimpiaFiltro.Enabled = DatoFiltroPanel != null; }

        }
        /// <summary>
        /// Handle que se ejecuta cuando se aplican los filtros al GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="EventArgs"/> instancia de la clase con los datos del evento.</param>
        protected void btnFiltro_Click(object sender, EventArgs e)
        {
            try
            {
                ControlDato.CrearEntidad();
                dynamic nentidad = ControlDato.Dato;
                (nentidad as TipoBase).FijarConfiguracionDinamica(ControlDato.InformacionUsers);
                TablaControles.RellenarEntidad(tbFiltro, ref nentidad, "wfiltro");
                DatoFiltroPanel = nentidad;
                MostrarGrid(AplicarConfiguracionWEB ? ConfiguracionUser.actualizar_al_filtrar : ActualizarAlFiltrar);

            }
            catch (Exception ex)
            {
                lblError.Text = "No se logro aplicar el filtro:" + Utilerias.getMsgError(ex);
            }
            finally
            {
                btnLimpiaFiltro.Enabled = DatoFiltroPanel != null;
            }
        }

        

        /// <summary>
        /// Handle que se ejecuta cuando se carga completamente la pagina.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="EventArgs"/> instancia de la clase con los datos del evento.</param>
        void PaginaBase_LoadComplete(object sender, EventArgs e)
        {

            Utilerias.CerrarNotificacionesModal(this.Page);

        }


        /// <summary>
        /// Metoto para visualizar los botones en el GridView.
        /// </summary>
        /// <param name="grid">El componente GridView.</param>
        public void dijuarBotones(GridView grid)
        {
            // grid.RowEditing -= new GridViewEditEventHandler(Grid_RowEditing);

            //grid.RowCancelingEdit += new GridViewCancelEditEventHandler(Grid_RowCancelingEdit);
            //grid.RowUpdating += new GridViewUpdateEventHandler(Grid_RowUpdating);

        }
        #endregion

        #region Metodos privados

        /// <summary>
        /// Metodo encargado de configurar los componentes que usa el Delta Grid.
        /// </summary>
        /// <param name="actualizar"> Indica si se debe actualizar los datos, o se deben obtener de la memoria.</param>
        protected internal void ConfigurarDatos(bool actualizar = false)
        {
            try
            {
                dynamic controlTemp = null;
                this.Page.LoadComplete += new EventHandler(PaginaBase_LoadComplete);                
                this.Page.Header.Controls.Add(Utilerias.CrearLinkCSS(this.Page, this.GetType(), "Delta_webControl.css.pkCSS.css"));
                this.Page.Header.Controls.Add(Utilerias.CrearLinkCSS(this.Page, this.GetType(), "Delta_webControl.css.jquery.window.css"));
                this.Page.Header.Controls.Add(Utilerias.CrearLinkCSS(this.Page, this.GetType(), "Delta_webControl.css.contextmenu.css"));


                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jwindow", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.jquery.window.min.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnoty", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.jquery.noty.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyTCenter", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.topCenter.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyTRight", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.topRight.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyTLeft", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.topLeft.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyDef", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.default.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "core", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.pkCore.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jnotyInline", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.Notificacion.inline.js"));
                this.Page.ClientScript.RegisterClientScriptInclude(this.Page.GetType(), "jcontexmenu", Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.js.jquery.contextmenu.js"));

                btnLimpiaFiltro.Enabled = DatoFiltroPanel != null;

                dijuarBotones(grdRegistros);
                lblError.Text = "";

                if (ControlDato == null)
                {
                    if (_tipo_dato == null)
                        throw new Exception("El tipo de dato no fue encontrado.");

                    if (_tipo_dato == typeof(TablasGral))
                    {
                        controlTemp = new ControlBase<TablasGral>();
                    }
                    else if (controlTemp == null)
                    {
                        object tipoEntidad = Comun.ObtenerTipo(_tipo_dato.Assembly.GetName(true).Name, _tipo_dato.FullName);
                        controlTemp = Comun.CrearInstanciaGenerico(typeof(ControlBase<>), tipoEntidad.GetType());

                    }
                    if (controlTemp == null)
                        throw new Exception("No se logro generar el control de la entidad, revise la configuración");

                    if (ConfiguracionUser == null)
                    {
                        controlTemp.CargarConfiguracionUser(null, null);
                        ControlDato = controlTemp;
                    }

                }


                ImprimirFunciones();



                if (TablaControles == null)
                    ConfigurarTablaUI();
                if (!Page.IsPostBack)
                {
                    GuardarEntidadMemoria(null);
                    this.ConfigurarUI();
                    if (this.DeltaPadre == null)
                        this.MostrarGrid(true);
                    Utilerias.ExecScript(this.Page, "ConfigurarAjax();", "configAjax");
                    this.RellenarDefault();
                    this.btnNuevo.OnClientClick = "MostrarEdicion_" + this.ID + "(false,'" + Utilerias.Encriptar(this.ID, ConfigProy.claveKey) + "','','" + Utilerias.Encriptar(Utilerias.SerializarJSon(ParametrosDef), ConfigProy.claveKey) + "'); return false;";
                }
                else
                {
                    this.ConfigurarUI();
                    if (this.DeltaPadre == null && !(this.Page.Request.Params["__EVENTARGUMENT"].IndexOf("Page$") >= 0 && this.Page.Request.Params["__EVENTTARGET"] == this.grdRegistros.UniqueID))
                        this.MostrarGrid();
                }


                this.ConfigurarPanelFiltro(!Page.IsPostBack);
                if (EntidadMaster != null)
                    this.btnNuevo.OnClientClick = "MostrarEdicion_" + this.ID + "(false,'" + Utilerias.Encriptar(ID, ConfigProy.claveKey) + "','','" + Utilerias.Encriptar(Utilerias.SerializarJSon(ParametrosDef), ConfigProy.claveKey) + "'); return false;";
            }
            catch (Exception ex)
            {
                lblError.Text = "[" + this.Titulo + "]No se logro cargar los datos:" + Utilerias.getMsgError(ex);
            }
        }
        /// <summary>
        /// Metodo encargado de configurar e imprimir las funciones javascript que usa el Delta Grid.
        /// </summary>
        protected void ImprimirFunciones()
        {
            Hashtable tbEstatus = Delta_grid.ObtenerEstadosGlobales(this.Page, Tag);
            if (tbEstatus == null)
                tbEstatus = new Hashtable();
            string strreferencia = "&ref=" + Utilerias.Encriptar(Referencia, ConfigProy.claveKey);
            string url_editor = RutaEditor;
            string url_importar = RutaImportar;
            string url_config_datos = ruta_cargador;
            string url_tipos_datos = ruta_cargador;
            string url_Editores = ruta_cargador;
            string url_TipoDatos = ruta_cargador;
            string url_TipoFiltros = ruta_cargador;
            string url_TipoOperaciones = ruta_cargador;
            bool verTodosCampos = Delta_grid.ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES.CONFIGURAR_CAMPOS, tbEstatus);
            bool verCampos = Delta_grid.ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES.CONFIGURAR_CAMPOS, tbEstatus);
            bool verEditores = Delta_grid.ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES.VER_EDITORES, tbEstatus);
            bool verTipoDatos = Delta_grid.ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES.VER_TIPOS_COLUMNAS, tbEstatus);
            bool verFiltros = Delta_grid.ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES.VER_FILTROS, tbEstatus);
            bool verOperaciones = Delta_grid.ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES.VER_OPERACIONES, tbEstatus);
            var strTPEncript = string.Empty;
            var strTGralEncript = string.Empty;
            var strFTablaGralEncript = string.Empty;

            if (ruta_cargador != null)
            {
                var tag_dg = Utilerias.Encriptar(this.Tag, ConfigProy.claveKey);
                url_tipos_datos = url_tipos_datos + "?url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmCamposTabla", ConfigProy.claveKey) + "&tag=" + tag_dg;
                url_config_datos = url_config_datos + "?cl=" + ClaveTipoTabla.ToString() + "&tp=" + TipoBaseControl.FullName + "&url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmCamposTabla", ConfigProy.claveKey) + "&tag=" + tag_dg; ;
                url_Editores = url_Editores + "?tp=0&url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmListaEditores", ConfigProy.claveKey) + "&tag=" + tag_dg; ;
                url_TipoDatos = url_TipoDatos + "?tp=0&url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmListaTipos", ConfigProy.claveKey) + "&tag=" + tag_dg; ;
                url_TipoFiltros = url_TipoFiltros + "?tp=0&url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmListaFiltros", ConfigProy.claveKey) + "&tag=" + tag_dg; ;
                url_TipoOperaciones = url_TipoOperaciones + "?tp=0&url=" + Utilerias.Encriptar("Delta_webControl.Admin.FrmListaOperaciones", ConfigProy.claveKey) + "&tag=" + tag_dg; ;

            }
            System.Text.StringBuilder strFuncion = new System.Text.StringBuilder();
            //{0} this.uniqueid,{1} btn nuevo unique id

            strFuncion.Append("var id_contenedor='{0}';");
            strFuncion.Append("var win_{0}=null;");
            strFuncion.Append("var cambio_{0}=false;");


            strFuncion.Append("function configInicial_{0}(){ ");
            strFuncion.Append("PintarMenu_{0}();");
            if (this.MostrarFiltro)
            {
                strFuncion.Append("if(getCookie('edoPanel_{0}')!='1')$('#{0}_pnlFiltro').slideUp();");
            }
            strFuncion.Append("}");

            if (this.MostrarFiltro)
            {
                strFuncion.Append("$('#titFiltro_{0}').click(function() {");
                strFuncion.Append("$('#{0}_pnlFiltro').slideUp();");
                strFuncion.Append("if($('#{0}_pnlFiltro').is(':hidden')){");
                //strFuncion.Append("alert('mostrar');");
                strFuncion.Append("$('#{0}_pnlFiltro').slideDown();");
                strFuncion.Append("setCookie('edoPanel_{0}','1');}else{");
                //strFuncion.Append("alert('Ocultar');");
                strFuncion.Append("setCookie('edoPanel_{0}','0');}");
                strFuncion.Append("return false;");
                strFuncion.Append("});");
            }

            strFuncion.Append("function PintarMenu_{0}(){");
            if (VisualizarMenuContextual)
            {
                strFuncion.Append(" var option_{0} = { width: 300,");
                strFuncion.Append("items: [{icon:'" + Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.imagenes.editores.png") + "',text:\"<span class='TituloMenuContex'>OPCIONES DEL DELTA GRID [" + this.lbltitulo.Text.ToUpper() + "]</span>\",alias:'tit',type:'ibody'}");


                if (verCampos)
                {
                    strFuncion.Append(",");
                    strFuncion.Append("{ type: 'splitLine' },{icon:'" + Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.imagenes.config.png") + "',text:\"<span class='ItemMenuContex'>Configurar campos</span>\",alias:'op0',action:function(){MostrarVentana('Campos registrados del tipo " + this.Titulo + "','" + url_config_datos + "',null);}}");
                }

                if (verTodosCampos)
                {
                    strFuncion.Append(",");
                    strFuncion.Append("{ type: 'splitLine' },{icon:'" + Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.imagenes.config.png") + "',text:\"<span class='ItemMenuContex'>Ver tipos configurados</span>\",alias:'op1',action:function(){MostrarVentana('Tipos de datos configurados','" + url_tipos_datos + "',null);}}");
                }

                if (verEditores)
                {
                    strFuncion.Append(",");
                    strFuncion.Append("{ type: 'splitLine' },{icon:'" + Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.imagenes.editores.png") + "',text:\"<span class='ItemMenuContex'>ver editores</span>\",alias:'op2',action:function(){MostrarVentana('Lista de editores registrados','" + url_Editores + "',null);}}");
                }

                if (verTipoDatos)
                {
                    strFuncion.Append(",");
                    strFuncion.Append("{ type: 'splitLine' },{icon:'" + Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.imagenes.tipos_dato.gif") + "',text:\"<span class='ItemMenuContex'>Ver tipos de datos</span>\",alias:'op3',action:function(){MostrarVentana('Lista de tipos de datos','" + url_TipoDatos + "',null);}}");
                }
                if (verFiltros)
                {
                    strFuncion.Append(",");
                    strFuncion.Append("{ type: 'splitLine' },{icon:'" + Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.imagenes.filtro.gif") + "',text:\"<span class='ItemMenuContex'>Ver tipos de filtros</span>\",alias:'op4',action:function(){MostrarVentana('Lista de controles para filtros','" + url_TipoFiltros + "',null);}}");
                }

                if (verOperaciones)
                {
                    strFuncion.Append(",");
                    strFuncion.Append("{ type: 'splitLine' },{icon:'" + Page.ClientScript.GetWebResourceUrl(this.GetType(), "Delta_webControl.imagenes.check.png") + "',text:\"<span class='ItemMenuContex'>Ver tipos de operaciones</span>\",alias:'op6',action:function(){MostrarVentana('Lista de operaciones','" + url_TipoOperaciones + "',null);}}");
                }
                strFuncion.Append("],");
                strFuncion.Append("onShow: function(menu){menu.applyrule({name:'r1',disable:true,items:['tit']});}");

                strFuncion.Append("};");

                if (VisualizarMenuContextual)
                    strFuncion.Append("$('#" + this.ID + "_pnlBarra').contextmenu(option_{0},'" + this.ID_COMPONENTE + "');");


            }
            strFuncion.Append("}");
            strFuncion.Append("function CerrarVentana_{0}(cambioWin) {");
            strFuncion.Append("cambio_{0} = cambioWin;");
            strFuncion.Append("if (win_{0} != null)");
            strFuncion.Append("win_{0}.close();");
            strFuncion.Append("}");
            strFuncion.Append("function ActualizarGrid_{0}()");
            strFuncion.Append("{");
            strFuncion.Append("ventana = null;");
            strFuncion.Append("if(cambio_{0}){");
            strFuncion.Append("__doPostBack('{1}', '');");
            strFuncion.Append("pkMsgModal('Actualizando grid, espere porfavor.......','" + this.UpdatePanel1.ClientID + "');");
            strFuncion.Append("}");
            strFuncion.Append("}");
            strFuncion.Append("function MostrarEdicion_{0}(edicion,clave,data,parametros,fila) {");
            strFuncion.Append("try {");
            strTPEncript = Utilerias.Encriptar(_tipo_dato.FullName, ConfigProy.claveKey);
            strTGralEncript = Utilerias.Encriptar(IdTipoGral.ToString(), ConfigProy.claveKey);
            strFTablaGralEncript = Utilerias.Encriptar(this.FolioTablaGral.ToString(), ConfigProy.claveKey);

            if (url_editor != null)
            {
                strFuncion.Append("var titulo = edicion == undefined || edicion ? 'Edición de dato' : 'Nuevo registro';");
                strFuncion.Append("cambio = false;");
                strFuncion.Append("win_{0} = $.window({");
                strFuncion.Append("title: titulo,");
                strFuncion.Append("draggable: false,");
                strFuncion.Append("showModal: true,");
                strFuncion.Append("minimizable: false,");
                strFuncion.Append("bookmarkable: false,");
                strFuncion.Append("icon:null,");
                strFuncion.Append("width:$(window).innerWidth()-100,");
                strFuncion.Append("height:$(window).innerHeight()-100,");
                strFuncion.Append("scrollable: true,");
                strFuncion.Append("onClose: ActualizarGrid_{0},");
                strFuncion.Append("onShow: function () { CerrarMsgModal(); },");
                strFuncion.Append("url: '" + url_editor + "&fl='+(fila==undefined?'':fila)+'&kv=' + clave+'&dat='+data+'&def='+parametros+'&tp=" +
                    strTPEncript +
                    "&id=" + strTGralEncript +
                    "&f=" + strFTablaGralEncript + strreferencia + "'");
                strFuncion.Append("});");                
            }
            else
                strFuncion.Append("alert('No se ha especificado la URL del editor.');");

            strFuncion.Append("} catch (ex) { alert('Error al cargar la pagina de captura:' + ex); }");
            strFuncion.Append("}");
            ////
            strFuncion.Append("function MostrarImportar_{0}() {");
            strFuncion.Append("try {");
            if (url_importar != null)
            {
                strFuncion.Append("var titulo = 'Importación de datos';");
                strFuncion.Append("cambio = false;");
                strFuncion.Append("win_{0} = $.window({");
                strFuncion.Append("title: titulo,");
                strFuncion.Append("draggable: false,");
                strFuncion.Append("showModal: true,");
                strFuncion.Append("minimizable: false,");
                strFuncion.Append("bookmarkable: false,");
                strFuncion.Append("width:500,");
                strFuncion.Append("height:300,");
                strFuncion.Append("scrollable: true,");
                strFuncion.Append("onClose: ActualizarGrid_{0},");
                strFuncion.Append("onShow: function () { CerrarMsgModal(); },");
                strFuncion.Append("url: '" + url_importar + "&tp=" +
                    strTPEncript + "&id=" + strTGralEncript +
                    "&kv=" + Utilerias.Encriptar(this.ID, ConfigProy.claveKey) +
                    "&f=" + strFTablaGralEncript + strreferencia + "'");
                strFuncion.Append("});");
            }
            else
                strFuncion.Append("alert('No se ha configurado la URL de la pantalla de importación.');");
            strFuncion.Append("} catch (ex) { alert('Error al cargar la pagina de importación:' + ex); }");
            strFuncion.Append("}");
            strFuncion.Append("configInicial_{0}();");
            Utilerias.ExecScript(this.Page, strFuncion.ToString().Replace("{0}", this.ID).Replace("{1}", btnNuevo.UniqueID), "ctrlfuncions_" + this.ID);
        }

        /// <summary>
        /// Metodo que se encarga de configurar el panel de filtro que usa el Delta Grid.
        /// </summary>
        private void ConfigurarTablaUI()
        {
            if (this.MostrarFiltro && this.TablaControles == null)
            {
                this.TablaControles = new Delta_webrender.Dynamic.TablaUI();
                this.TablaControles.ValidacionDibujarAtributo = (Atpropiedad, Ateditor, Attipo, Atfiltro, AteditorFiltro) => { return Atfiltro != null; };
                this.TablaControles.ValidacionDibujarConfig = (config) => { return config.id_cat_filtro_campo > 0; };
                this.TablaControles.contenedor = this.ID;
                if (this.EsDinamico)
                    Comun.EjecutarMetodoObjGet(ControlDato, "CargarConfiguracionUser", null, ClaveTipoTabla > 0 ? ClaveTipoTabla : -1);
                this.TablaControles.configUsers = Comun.ObtenerValorPropiedad<List<dynamic>>(ControlDato, "ConfiguracionDatosUsers");
                this.TablaControles.tipo = EsDinamico ? null : TipoBaseControl;

            }
        }
        /// <summary>
        /// Se encarga de configurar el estado de los componentes.
        /// </summary>
        private void ConfigurarUI()
        {
            bool aplicarConfiguracionWeb = this.ConfiguracionUser != null && this.ConfiguracionUser.configuracion_web;
            bool registroSeleccionEnlace = (this.EntidadMaster != null && this.DeltaPadre != null) || this.DeltaPadre == null;
            this.btnNuevo.Enabled = registroSeleccionEnlace && (Utilerias.DefinicionEstatusUI(EstatusUI[Enumerados.TIPO_OPERACION_GRID.INSERTAR]) &&
                (aplicarConfiguracionWeb ? ConfiguracionUser.operaciones.Exists((op) => { return op.id_operacion == (Int16)Enumerados.TIPO_OPERACION_GRID.INSERTAR; })
                : AtributosEntidad.operaciones.Contains(Enumerados.TIPO_OPERACION_GRID.INSERTAR)));

            

        }
        /// <summary>
        /// Guarda la entidad en la memoria.
        /// </summary>
        /// <param name="valor">La entidad a guardar.</param>
        private void GuardarEntidadMemoria(object valor)
        {
            Comun.FijarValorSesion(this.Page, Constantes.claveEntidad + this.ID, valor);
        }
        #endregion
        #region Metodos publicos

        /// <summary>
        /// Metodo que se encarga de recargar la lista.
        /// </summary>
        /// <param name="soloActulizarBotones">Valor lógico que me indica si solo actualiza el estatus de los botones de la lista.</param>
        public void RecargarLista(bool soloActulizarBotones = false)
        {
            this.grdRegistros.SelectedIndex = -1;

            this.MostrarGrid(true, null, soloActulizarBotones);
            this.UPanel.Update();
        }
        /// <summary>
        /// Meotodo generico que obtiene los datos de la entidad seleccionada actualmente, este metodo permite indicar el tipo de dato de la entidad, ya que internamente
        /// se maneja como object.
        /// </summary>
        /// <typeparam name="TP">Tipo de la entidad  que herede TipoBase.</typeparam>
        /// <returns>Entidad convertida.</returns>
        public TP DatosEntidadActual<TP>() where TP : TipoBase, new()
        {
            return (TP)this.EntidadActual;
        }
        /// <summary>
        /// Se encarga de ejecutar un metodo de la clase control.
        /// </summary>
        /// <param name="metodo">Nombre del meotodo a ejecutar.</param>
        /// <param name="parametros">Lista de parametros del metodo.</param>
        public void EjecutarMetodo(string metodo, params object[] parametros)
        {

            MethodInfo propTipo = this.ControlDato.GetType().GetMethod(metodo);
            if (propTipo != null)
            {
                ArrayList def_parametros = new ArrayList();
                if (parametros == null || parametros.Length == 0)
                {
                    foreach (ParameterInfo par in propTipo.GetParameters())
                    {
                        def_parametros.Add(par.DefaultValue);
                    }
                    parametros = def_parametros.ToArray();
                }
                propTipo.Invoke(ControlDato, parametros.Count() == 0 ? null : parametros);
            }
        }
        /// <summary>
        /// Este metodo se encarga de filtrar datos de la tabla, acepta como parametro una entidad del TipoBase, puede enviar los parametros en la entidad del mismo 
        /// tipo que el Delta Grid, recuerde que el Delta Grid envia a al procedimiento almacenado, los campos que fueron configurados para la operación de ObtenerVarios.
        /// </summary>
        /// <param name="datos">Los datos del filtro a aplicar.</param>
        public void FiltrarDatos(TipoBase datos)
        {
            this.MostrarGrid(true, datos);
        }

        #endregion

        #region Metodos para los filtros
        /// <summary>
        /// Metodo encargado de actualizar los componentes que integran el panel de filtros.
        /// </summary>
        private void ActualizarListadoFiltros()
        {
            foreach (Cat_campo_tecnico campo in this.camposFiltrosTb.Keys)
            {
                string valSel = (this.camposFiltrosTb[campo] as DropDownList).SelectedValue;

                (this.camposFiltrosTb[campo] as DropDownList).Items.Clear();
                (this.camposFiltrosTb[campo] as DropDownList).Items.Add(new ListItem("Todos", ""));
                if (this.ListaCtrl != null)
                    foreach (TipoBase entidad in this.ListaCtrl as dynamic)
                    {
                        string val = entidad.ObtenerValor<string>(campo.nombre);
                        ListItem nitem = new ListItem(val, val);
                        if (!(this.camposFiltrosTb[campo] as DropDownList).Items.Contains(nitem))
                            (this.camposFiltrosTb[campo] as DropDownList).Items.Add(entidad.ObtenerValor<string>(campo.nombre));
                    }
                (this.camposFiltrosTb[campo] as DropDownList).SelectedValue = valSel;
            }

        }
        /// <summary>
        /// Metodo encargado de dibujar los componentes del panel de filtro, de acuerdo a la configuración especificada en la entidad o en la web.
        /// </summary>
        /// <param name="actualizar">if set to <c>true</c> [actualizar].</param>
        public void ConfigurarPanelFiltro(bool actualizar)
        {
            dynamic tmpLista = this.AplicarConfiguracionWEB && !this.ConfiguracionUser.guardar_lista_en_cache ? this.ControlDato.Lista : ListaCtrl;
            if (actualizar)
            {
                this.ConfigurarTablaUI();
            }
            if (!this.MostrarFiltro)
            {
                if (this.pnlContenedorFiltro.Controls.Count > 0)
                {
                    this.pnlContenedorFiltro.Controls.Clear();
                }

                //pnlFiltro.Controls.Clear();               
                return;
            }

            if (this.pnlContenedorFiltro.Controls.Count == 0)
            {
                this.pnlContenedorFiltro.Controls.Add(ltPanelFiltro);
                this.pnlContenedorFiltro.Controls.Add(pnlFiltro);

            }

            int controlesDibujados = 0;
            foreach (Cat_campo_tecnico campo in this.TablaControles.listaCamposDibujar)
            {
                Label lbltex = new Label() { Text = campo.titulo, CssClass = "CampoFiltro" };
                Control ntex = null;
                if (campo.filtro.tomar_valor_grid)
                {

                    ntex = new DropDownList();
                    (ntex as DropDownList).Items.Add(new ListItem("Todos", ""));
                    if (tmpLista != null)
                        foreach (TipoBase entidad in tmpLista as dynamic)
                        {
                            string val = entidad.ObtenerValor<string>(campo.nombre);
                            if (val != null)
                            {
                                ListItem nitem = new ListItem(val, val);
                                if (!(ntex as DropDownList).Items.Contains(nitem))
                                    (ntex as DropDownList).Items.Add(entidad.ObtenerValor<string>(campo.nombre));
                            }
                        }
                    camposFiltrosTb[campo] = ntex;
                }
                else
                {
                    if (string.IsNullOrWhiteSpace(campo.editorFiltro.ensamblado))
                        ntex = new TextBox();
                    else
                    {
                        if (string.IsNullOrWhiteSpace(campo.editorFiltro.ensamblado))
                            campo.editorFiltro.ensamblado = typeof(TextBox).Assembly.FullName;
                        ntex = (Control)Comun.ObtenerTipo(campo.editorFiltro.ensamblado, campo.editorFiltro.editor);
                    }


                }
                if (ntex == null)
                    ntex = new TextBox();
                ntex.ID = ID + "|wfiltro|" + campo.nombre;
                ntex.ClientIDMode = System.Web.UI.ClientIDMode.Static;
                TablaControles.ConfigurarCampo(ref ntex, campo, this.Page);

                tbFiltro.Rows[tbFiltro.Rows.Count - 2].Cells.Add(TablaUI.CrearCelda(this.ID_COMPONENTE + "_tit_" + campo.nombre, lbltex));
                tbFiltro.Rows[tbFiltro.Rows.Count - 2].Cells.Add(TablaUI.CrearCelda(this.ID_COMPONENTE + "_ctrl_" + campo.nombre, ntex));
                controlesDibujados++;
                if (controlesDibujados == 2)
                {
                    tbFiltro.Rows.AddAt(tbFiltro.Rows.Count - 1, TablaUI.CrearFIla(this.ID + "_fila_controles" + tbFiltro.Rows.Count.ToString()));
                    controlesDibujados = 0;
                }
                //this.pnlFiltro.Controls.Add(lbltex);
                //this.pnlFiltro.Controls.Add(ntex);
            }



        }
        #endregion

        #region Metodos para manipular el grid
        /// <summary>
        /// Metodo que se encarga de configurar el Delta Grid de solo consulta, es decir, no va a permitir eliminar, editar,editar con EXCEL e importar.
        /// </summary>        
        /// <exception cref="System.Exception">No se ha configurado un Query para rellenar la tabla</exception>
        protected internal void ConfigurarTablaSoloConsulta()
        {
            Cat_tipo_gral infoTablaGral = null;            
            btnNuevo.Visible = false;            
            Comun.EjecutarMetodoObjGet(ControlDato, "CargarConfiguracionUser", null, ClaveTipoTabla > 0 ? ClaveTipoTabla : -1);
            infoTablaGral = (Cat_tipo_gral)Comun.ObtenerValorPropiedad(ControlDato, "InformacionUsers");
            if (infoTablaGral != null)
                Query_Ejecutar = infoTablaGral.consulta;
            if (string.IsNullOrWhiteSpace(Query_Ejecutar) && infoTablaGral == null)
                throw new Exception("No se ha configurado un Query para rellenar la tabla");


            DataTable dtDatos = Comun.EjecutarMetodoObjGet(ControlDato, "EjecutarComando", Query_Ejecutar, this.MostrarFiltro, this.DatoFiltroPanel, this.TablaControles == null ? null : TablaControles.listaCamposDibujar, ParametrosFiltroLista);

            if (infoTablaGral.campos != null && infoTablaGral.campos.Count > 0)
                ctrlGrid.AplicarFormatoGrid(this.Page, base.GetType(), TipoBaseControl, this.grdRegistros, null,
                   infoTablaGral, false, false, null);

            this.grdRegistros.DataSource = dtDatos.DefaultView;
            this.grdRegistros.DataBind();

        }



        /// <summary>
        /// Este metodo es el encargado de mostrar los datos en el GridView, asi como tambien aplicar el formato a las columnas.
        /// </summary>
        /// <param name="actualizar">Indica si los datos se obtienen de la base de datos (true) o de la memoria (false)</param>
        /// <param name="parametros">Entidad que herede a TipoBase, la cual contiene los valores a aplicar en la obtención de datos.</param>
        /// <param name="soloActualizarBotones">Indica si es solo actualizar los botones del GridView, los botones son Eliminar,Editar y Seleccionar.</param>
        protected internal void MostrarGrid(bool actualizar = false, TipoBase parametros = null, bool soloActualizarBotones = false)
        {
            bool guardarLista = true;

            if ((AtributosEntidad != null && !AtributosEntidad.guardarListaEnCache) || (AplicarConfiguracionWEB && !ConfiguracionUser.guardar_lista_en_cache))
            {
                actualizar = true;
                guardarLista = false;
            }

            if (ListaCtrl == null && !actualizar)
                actualizar = true;

            if (parametros == null && this.ParametrosFiltroLista != null && !this.Page.IsPostBack)
            {
                parametros = (TipoBase)Comun.CrearInstancia(this.TipoBaseControl.FullName);
                Comun.RellenarEntidad(this.ParametrosFiltroLista, parametros);
            }
            if (parametros != null)
                this.DatoFiltro = parametros;
            if (this.EsConsulta)
            {
                this.ConfigurarTablaSoloConsulta();
                return;
            }
            Type tipodatoReal = this.TipoBaseControl;
            if (actualizar)
                this.ControlDato.LimpiarDato();

            if (this.IdTipoGral > 0)
            {
                TablasGral ndatos = new TablasGral() { id_tipo_gral = this.IdTipoGral, folio = this.FolioTablaGral, referencia1 = this.Referencia };
                this.ControlDato.Obtener(ndatos);
                this.EntidadActual = ControlDato.Dato;
                tipodatoReal = typeof(ItemGral);
                ControlDato.CargarConfiguracionUser(null, this.IdTipoGral);
            }

            if (actualizar)
            {

                if (this.IdTipoGral > 0)
                {
                    if (guardarLista)
                    {
                        this.ListaCtrl = this.ControlDato.ObtenerListadoTablaXML(ParametrosFiltroLista);
                        this.ControlDato.ListaDinamica = this.ListaCtrl;
                    }

                }
                else
                {
                    if (this.DatoFiltro == null)
                    {
                        dynamic entidadParametros = Comun.CrearInstancia(this.TipoBaseControl);
                        //this.EjecutarMetodo("ObtenerListado", this.RellenarParametrosMaster((TipoBase)Comun.CrearInstancia(this.TipoBaseControl.FullName)), 0);
                        this.RellenarParametrosMaster(ref entidadParametros);
                        ControlDato.ObtenerListado(entidadParametros, 0);
                        entidadParametros = null;
                    }
                    else
                    {
                        //this.EjecutarMetodo("ObtenerListado", this.DatoFiltro, 0);
                        dynamic entidadParametros = Comun.Convertir(this.DatoFiltro, TipoBaseControl);
                        ControlDato.ObtenerListado(entidadParametros, 0);
                        entidadParametros = null;
                    }
                    if (guardarLista)
                        this.ListaCtrl = this.ControlDato.Lista;
                }


            }
            else
            {
                if (!EsDinamico)
                    this.ControlDato.Lista = this.ListaCtrl;
                else
                    this.ControlDato.ListaDinamica = this.ListaCtrl;
            }


            this.grdRegistros.DataSource = ControlDato.ListaATabla(this.MostrarFiltro, this.DatoFiltroPanel, this.TablaControles == null ? null : this.TablaControles.listaCamposDibujar, ParametrosFiltroLista);

            AttEntidad datosEntidad = Utilerias.ObtenerAtributoPropiedad<AttEntidad>(this.TipoBaseControl);
            string keys = datosEntidad != null ? datosEntidad.keys : "";
            if (this.EsDinamico)
                keys = "Fila";
            ctrlGrid.AplicarFormatoGrid(this.Page, base.GetType(), tipodatoReal, this.grdRegistros, keys,
                ControlDato.InformacionUsers /*Comun.ObtenerValorPropiedad<Cat_tipo_gral>(ControlDato, "InformacionUsers")*/,
                this.EdicionMem, this.EliminarMem, null, datosEntidad.operaciones);




            //Antes del Binding, actualizo las variables encriptadas

            this.ID_Enc = Utilerias.Encriptar(ID, ConfigProy.claveKey);
            this.Parametros_Enc = Utilerias.Encriptar(Utilerias.SerializarJSon(ParametrosDef), ConfigProy.claveKey);

            if ((!Page.IsPostBack && !this.Page.IsCallback) || actualizar || soloActualizarBotones)
            {

                if ((this.grdRegistros.DataSource as DataView).Count == 1 && this.grdRegistros.SelectedIndex < 0 && !soloActualizarBotones && PermiteSeleccionar)
                {
                    this.limpiarEntidades = false;
                    this.grdRegistros.SelectedIndex = 0;
                    this.grdRegistros.DataBind();
                    this.grdRegistros_SelectedIndexChanged(this.grdRegistros, null);

                }
                else
                    this.grdRegistros.DataBind();
            }
            else
                this.grdRegistros.DataBind();
        }


        /// <summary>
        /// Handle que se ejecuta cuando se selecciona una fila del GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="EventArgs"/> instancia de la clase con los datos del evento.</param>
        protected void grdRegistros_SelectedIndexChanged(object sender, EventArgs e)
        {


            if (grdRegistros.SelectedIndex >= 0)
                this.EntidadActual = (ListaCtrl as dynamic)[this.grdRegistros.Rows[this.grdRegistros.SelectedIndex].DataItemIndex];//[grdRegistros.SelectedIndex];
            else
                this.EntidadActual = null;


            if (this.ListaEnlaces != null && this.ListaEnlaces.Count > 0)
            {
                this.PasarVariablesEnlace();

            }
            if (this.SeleccionFila != null)
                this.SeleccionFila(sender, e);

        }

        /// <summary>
        /// Handle que se ejecuta cuando se cancela una edición del GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="GridViewCancelEditEventArgs"/> instancia que contiene los datos del evento.</param>
        protected void Grid_RowCancelingEdit(object sender, GridViewCancelEditEventArgs e)
        {
            (sender as GridView).EditIndex = -1;
            (sender as GridView).DataBind();
        }

        /// <summary>
        /// Handle que se ejecuta cuando se confirma la edición de una fila en el GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="GridViewUpdateEventArgs"/> instancia que contiene los datos del evento.</param>
        protected void Grid_RowUpdating(object sender, GridViewUpdateEventArgs e)
        {

            try
            {
                //EjecutarMetodo("CrearNuevoDato");
                //foreach (string clave in e.Keys.Keys)
                //{

                //    PropertyInfo propiedad = Utilerias.ObtenerPropiedadXAtributoXNombre<AttPropiedad>(TipoBaseControl, clave);

                //    if (propiedad != null)
                //    {
                //        Comun.EjecutarMetodoObj(DatoCtrl, "FijarValor", propiedad.Name, e.Keys[clave]);

                //    }
                //}

                //EjecutarMetodo("Obtener");

                //foreach (string nombre in e.NewValues.Keys)
                //{

                //    Comun.EjecutarMetodoObj(DatoCtrl, "FijarValor", nombre, e.NewValues[nombre]);

                //}

                //EjecutarMetodo("Insertar", ControlDato);
                //MostrarGrid(true);
                //Grid_RowCancelingEdit(sender, null);
                lblError.Text = "Edición InLine no soportada";
            }
            catch (Exception ex)
            {
                lblError.Text = "No se logro actualizar los datos:" + Utilerias.getMsgError(ex);
            }


        }


        /// <summary>
        /// Handle que se ejecuta cuando se inicia la edición de una fila del GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="GridViewEditEventArgs"/> instancia que contiene los datos del evento.</param>
        protected void Grid_RowEditing(object sender, GridViewEditEventArgs e)
        {

            e.Cancel = true;
            lblError.Text = "Edición InLine no soportada";
            //EjecutarMetodo("FijarLista", ListaCtrl);
            //EjecutarMetodo("SeleccionarIndice", grdRegistros.Rows[e.NewEditIndex].DataItemIndex);
            //GuardarEntidadMemoria(DatoCtrl);
            ////GuardarControlMemoria(ControlDato);

            //grdRegistros.SelectedIndex = e.NewEditIndex;
            //Utilerias.ExecScript(this.Page, "MostrarEdicion_" + this.ID + "(true,'" + Utilerias.Encriptar(ID, ConfigProy.claveKey) + "')", "FrmEdicion_" + this.ID);


        }



        /// <summary>
        /// Handle que se ejecuta cuando se elimina una fila del GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="GridViewDeleteEventArgs"/> instancia que contiene los datos del evento.</param>
        protected void grdRegistros_RowDeleting(object sender, GridViewDeleteEventArgs e)
        {
            try
            {
                this.grdRegistros.SelectedIndex = -1;
                bool esTablaGral = TipoBaseControl == typeof(TablasGral);
                ItemGral itemEliminar = null;
                if (esTablaGral)
                    itemEliminar = (EntidadActual as TablasGral).ObtenerItem(1, ControlDato.InformacionUsers);
                if (Antes_Eliminar_Grid != null)
                {
                    if (!esTablaGral)
                        Antes_Eliminar_Grid(sender, e, EntidadActual, EntidadMaster);
                    else
                        Antes_Eliminar_Grid(sender, e, itemEliminar, EntidadMaster);
                }
                if (!esTablaGral)
                {
                    dynamic entEliminar = Comun.CrearInstancia(TipoBaseControl);
                    //this.ControlDato.Lista = ListaCtrl;
                    //this.ControlDato.SeleccionarIndice(this.grdRegistros.Rows[e.RowIndex].DataItemIndex);
                    Comun.RellenarEntidad(Utilerias.ObtenerValoresClavesGrid(this.grdRegistros, e.RowIndex), entEliminar);
                    //Comun.RellenarEntidad(e.Values, entEliminar);
                    this.ControlDato.Dato = entEliminar;
                    this.ControlDato.Eliminar(null, true);
                }
                else
                {
                    TablasGral infoTabla = EntidadActual as TablasGral;
                    infoTabla.EliminarFila(this.grdRegistros.Rows[e.RowIndex].DataItemIndex + 1);
                    //Comun.EjecutarMetodoObj(ControlDato, "Insertar", infoTabla, true);
                    ControlDato.Insertar(infoTabla, true);
                    EntidadActual = infoTabla;
                }
                e.Cancel = true;
                this.MostrarGrid(true);
                if (Despues_Eliminar_Grid != null)
                {
                    if (!esTablaGral)
                        Despues_Eliminar_Grid(sender, e, EntidadActual, EntidadMaster);
                    else
                        Despues_Eliminar_Grid(sender, e, itemEliminar, EntidadMaster);
                }

            }
            catch (Exception ex)
            {
                lblError.Text = Utilerias.getMsgError(ex);
            }
            finally
            {
                this.ActualizarListadoFiltros();
                this.ConfigurarUI();
            }
        }

        /// <summary>
        /// Handle que se ejecuta cuando se cambia el numero de pagina del GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="GridViewPageEventArgs"/> instancia que contiene los datos del evento.</param>
        protected void grdRegistros_PageIndexChanging(object sender, GridViewPageEventArgs e)
        {
            this.grdRegistros.PageIndex = e.NewPageIndex;
            this.MostrarGrid();

            //this.grdRegistros.DataBind();
        }

        /// <summary>
        /// Handle que se ejecuta cuando se crean las celdas del GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="GridViewRowEventArgs"/> instancia que contiene los datos del evento.</param>
        protected void grdRegistros_RowDataBound(object sender, GridViewRowEventArgs e)
        {

            if (e.Row.RowType == DataControlRowType.DataRow)
            {

                //foreach (DataControlFieldCell cell in e.Row.Cells)
                //{
                DataControlFieldCell cell = e.Row.Cells[0] as DataControlFieldCell;
                foreach (Control control in cell.Controls)
                {

                    ImageButton button = control as ImageButton;
                    if (button != null && button.CommandName == "Delete")
                        button.OnClientClick = "if (!confirm('¿Desea eliminar el registro?')) return false; else pkMsgModal('Eliminando registro, espere.....');";

                    //if (button != null && button.CommandName == "Select")
                    //    button.OnClientClick = "pkMsgModal('Espere....');";
                    if (button != null && button.CommandName == "Edit")
                    {
                        int fila = e.Row.DataItemIndex + 1;
                        var filaEnc = string.Empty;
                        if (this.EsDinamico)
                        {
                            fila = Comun.Convertir<int>((e.Row.DataItem as DataRowView).Row["Fila"]);
                            filaEnc = Utilerias.Encriptar(fila.ToString(), ConfigProy.claveKey);
                        }
                        button.OnClientClick = string.Format("MostrarEdicion_{0}(true,'{1}','{2}','{3}','{4}');  return false;", this.ID,
                            ID_Enc,
                            Utilerias.Encriptar(Utilerias.SerializarJSon(Utilerias.ObtenerValoresClavesGrid(sender as GridView, e.Row.RowIndex)), ConfigProy.claveKey),
                            Parametros_Enc,
                            filaEnc);
                    }

                }
                //}
            }
            if (CreacionFila != null)
                CreacionFila(sender, e);
        }

        /// <summary>
        /// Handle que se ejecuta cuando se inserta un nuevo registro al GridView.
        /// </summary>
        /// <param name="sender">El componente que genero el evento.</param>
        /// <param name="e">La <see cref="EventArgs"/> instancia que contiene los datos del evento.</param>
        protected void btnNuevo_Click(object sender, EventArgs e)
        {
            MostrarGrid(true);
            ActualizarListadoFiltros();

        }
        #endregion

        #region Metodos para controlar el enlace

        /// <summary>
        /// Este metodo es interno, y solo se usa en Delta Grid enlazados, se encarga de registrar el Delta Grid ,pasado como parametro, como enlace.
        /// </summary>
        /// <param name="dl">El componente Delta Grid hijo que se agrega como enlace.</param>
        public void AgregarEnlace(Delta_grid dl)
        {
            if (!ListaEnlaces.Contains(dl))
                ListaEnlaces.Add(dl);

        }
        /// <summary>
        /// Rellenars the default.
        /// </summary>
        private void RellenarDefault()
        {

            if (this.ClavesEnlace == null || this.EntidadMaster == null)
            {
                this.ParametrosDef = null;
                return;
            }
            this.ParametrosDef = new Dictionary<string, object>();
            foreach (string clave in this.ClavesEnlace.Split(','))
                ParametrosDef.Add(clave, Comun.ObtenerValorPropiedad(this.EntidadMaster, clave));

        }
        /// <summary>
        /// Este metodo es interno, y solo se usa en Delta Grid enlazados, se ejecuta cuando se obtienen los datos de la tabla de los Delta Grid hijos, de acuerdo a la EntidadMaster seleccionada en el Delta Grid padre.
        /// </summary>
        /// <param name="Entidad">The entidad a la cual se le van a escribir los datos de la entidad master.</param>
        /// <returns>Entidad con los datos obtenidos de la entidad master.</returns>
        public TipoBase RellenarParametrosMaster(ref dynamic Entidad)
        {
            TipoBase _entidadMaster = this.EntidadMaster;
            if (_entidadMaster == null || string.IsNullOrWhiteSpace(this.ClavesEnlace))
                return null;
            else
            {
                foreach (string clave in this.ClavesEnlace.Split(','))
                {
                    Comun.FijarValorObjeto(Entidad, Comun.ObtenerValorPropiedad(this.EntidadMaster, clave), clave);
                }

                return Entidad;
            }

        }
        /// <summary>
        /// Este metodo es interno, y solo se usa en Delta Grid enlazados, se ejecuta cuando se selecciona un registro del Delta Grid padre, al ejecutarse, se envia a todos 
        /// los Delta Grid hijos, los datos de la entidad seleccionada y se guarda en la propiedad EntidadMaster de los Delta Grid hijos, esto para actualizar la tabla de estos ultimos.
        /// </summary>
        public void PasarVariablesEnlace()
        {
            if (this.ListaEnlaces == null)
                return;
            foreach (Delta_grid grdEnlace in this.ListaEnlaces)
            {

                grdEnlace.limpiarEntidades = false;
                if (grdEnlace.EsDinamico || grdEnlace.EsConsulta)
                {
                    grdEnlace.ParametrosFiltroLista = new Dictionary<string, object>();
                    foreach (string clave in grdEnlace.ClavesEnlace.Split(','))
                        grdEnlace.ParametrosFiltroLista.Add(clave, this.EntidadActual.ObtenerValor(clave));
                }
                grdEnlace.EntidadMaster = (TipoBase)Comun.ClonarEntidad(this.EntidadActual);//Utilerias.DeserializarJsonTo<TipoBase>(Utilerias.SerializarJSon(EntidadActual));
                grdEnlace.ConfigurarUI();
                grdEnlace.UPanel.Update();

            }




        }
        #endregion

        #region Metodos para enlaces y delegados de los controles extras


        /// <summary>
        /// Se encarga de reemplazar los datos de una propiedad de texto por los valores actuales de la entidad seleccionada en el Delta Grid, este metodo obtiene el valor 
        /// de la propiedad como texto, y reemplaza los valores configurados por los de la propiedad señalada, por ejemplo, si se desea crear un hyperlink y se necesitan valores de la entidad seleccionada, se hace lo siguiente:
        /// 
        //Suponiendo que tenemos un componente Hyperlink (objEnlace) y la propiedad NavigateUrl(propiedad_campo)
        //NavigateUrl="util/ConsultarNotaPedidoDetalle.aspx?clave={EntidadActual.Clave}"
        //Resultado="util/ConsultarNotaPedidoDetalle.aspx?clave=4"
        //suponiendo que el tipo de dato configurado para el Delta Grid contiene una propiedad o campo que se llame Clave y su valor sea 4.
        //Puede usar mas de un campo en una expresion.
        /// </summary>
        /// <param name="objEnlace">El control que contiene la propiedad a leer.</param>
        /// <param name="propiedad_campo">Propiedad de tipo String a la cual se le reemplazan los datos con los de la entidad.</param>
        /// <returns>Valor booleano que indica si se ejecuto correctamente el metodo.</returns>
        public bool RellenarVariablesCodigo(Control objEnlace, string propiedad_campo)
        {

            if (objEnlace == null)
                return false;
            string valorPropCampo = Comun.ObtenerValorPropiedad(objEnlace, propiedad_campo).ToString();

            System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex("{DP-[P-|V-|P+-|V+-]-[a-zA-Z_.]*}");
            System.Collections.ArrayList arrayList = new System.Collections.ArrayList();

            foreach (System.Text.RegularExpressions.Match match in regex.Matches(valorPropCampo))
            {
                if (!arrayList.Contains(match.Value))
                {
                    arrayList.Add(match.Value);
                }
            }
            foreach (string text in arrayList)
            {

                string[] info_clave = text.Replace("{", "").Replace("}", "").Split('-');
                string propiedad = info_clave[2];
                string tipo = info_clave[1];

                object datActual = this;
                foreach (string dato in propiedad.Split('.'))
                {
                    datActual = Comun.ObtenerDato(datActual, dato);
                    if (datActual == null)
                        break;
                }

                if (datActual != null)
                {

                    if (datActual is System.DateTime)
                    {
                        datActual = Comun.Convertir<System.DateTime>(datActual).ToString("dd/MM/yyyy");
                    }

                    valorPropCampo = valorPropCampo.Replace(text, datActual.ToString());
                }

            }

            Comun.FijarValorObjeto(objEnlace, valorPropCampo, propiedad_campo);
            return true;
        }


        /// <summary>
        /// Se encarga de reemplazar los datos de una propiedad de texto por los valores actuales de la entidad seleccionada en el Delta Grid
        /// </summary>
        /// <param name="ctrl">El control que contiene la propiedad a leer.</param>
        /// <param name="propiedad">Propiedad de tipo String a la cual se le reemplazan los datos con los de la entidad.</param>
        /// <returns>Valor booleano que indica si se ejecuto correctamente el metodo.</returns>
        public bool RegistrarPropiedadDinamica(Control ctrl, string propiedad)
        {

            return RellenarVariablesCodigo(ctrl, propiedad);
        }
        #endregion

        #region Metodos Estaticos

        /// <summary>
        /// Obtiene los permisos globales configurados con el metodo AsignarEstatusGlobales, devuelve un Hashtable con los permisos globales configurados y su valor logico asignado.
        /// </summary>
        /// <param name="pagina">La pagina donde se encuentra el componente Delta Grid.</param>
        /// <returns>Tabla con los permisos y valores configurados.</returns>
        /// <param name="tag">Identificador de la lista de estatus del Delta Grid,este identificador nos sirve para validar los permisos por usuario o por otro tipo de etiqueta.</param>
        public static Hashtable ObtenerEstadosGlobales(Page pagina, string tag = null)
        {
            if (tag == null)
                tag = Constantes.claveTagEstatusGlobales;
            if (pagina.Session[Constantes.claveEstatusGlobales + "_" + tag] != null)
                return (Hashtable)pagina.Session[Constantes.claveEstatusGlobales + "_" + tag];
            else
                return new Hashtable();
        }

        /// <summary>
        /// Permite obtener el valor de un permiso global, este metodo toma la tabla estatus para buscar el valor del permiso global. Devuelve un valor logico indicando si se cuenta o no con el permiso global.
        /// </summary>
        /// <param name="permiso">El permiso que se desea validar.</param>
        /// <param name="estatus">Listado de estatus globales configurados.</param>
        /// <returns>Valor logico que indica el valor configurado del permiso global.</returns>
        public static bool ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES permiso, Hashtable estatus)
        {
            bool? vDef = Comun.Convertir<bool?>(System.Configuration.ConfigurationManager.AppSettings["vdefEstatus"]);
            if (vDef == null)
                vDef = true;
            if (estatus != null)
            {
                if (estatus[permiso] == null)
                    return vDef.Value;
                return (bool)estatus[permiso];

            }
            return vDef.Value;

        }

        /// <summary>
        /// Permite obtener el valor de un permiso global, este metodo lee la tabla de estatus de la memoria y busca el valor del permiso global. Devuelve un valor logico indicando si se cuenta o no con el permiso global.
        /// </summary>
        /// <param name="permiso">El permiso que se desea validar.</param>
        /// <param name="pagina">La pagina donde se encuentra el componente Delta Grid.</param>
        /// <returns>Valor logico que indica el valor configurado del permiso global.</returns>
        /// <param name="tag">Identificador de la lista de estatus del Delta Grid,este identificador nos sirve para validar los permisos por usuario o por otro tipo de etiqueta.</param>
        public static bool ObtenerEstatusGlobales(Enumerados.PERMISOS_GLOBALES permiso, Page pagina, string tag = null)
        {
            bool? vDef = Comun.Convertir<bool?>(System.Configuration.ConfigurationManager.AppSettings["vdefEstatus"]);
            if (vDef == null)
                vDef = true;

            Hashtable estatus = null;
            if (tag == null)
                tag = Constantes.claveTagEstatusGlobales;
            if (pagina != null)
            {
                estatus = (Hashtable)pagina.Session[Constantes.claveEstatusGlobales + "_" + tag];
                if (estatus == null || estatus[permiso] == null)
                    return vDef.Value;
                return (bool)estatus[permiso];

            }
            return vDef.Value;

        }

        /// <summary>
        /// Se usa para asignar valor a los permisos globales, estos permisos afectan a todos los Delta Grid, el valor por default se toma del web.config de la clave vdefEstatus, 
        /// si no se configura esta clave, el valor por default es true.
        /// </summary>
        /// <param name="permiso">El permiso que se desea validar.</param>
        /// <param name="valor">Valor logico que se desea asignar al permiso global.</param>
        /// <param name="pagina">La pagina donde se encuentra el componente Delta Grid.</param>        
        public void AsignarEstatusGlobales(Enumerados.PERMISOS_GLOBALES permiso, bool valor, Page pagina)
        {
            Hashtable estatus = null;

            if (pagina != null)
            {
                estatus = (Hashtable)pagina.Session[Constantes.claveEstatusGlobales + "_" + this.Tag];
                if (estatus == null)
                    estatus = new Hashtable();
                estatus[permiso] = valor;
                pagina.Session[Constantes.claveEstatusGlobales + "_" + this.Tag] = estatus;

            }

        }


        /// <summary>
        /// Metodo que se encarga de asignar un valor a todos los estatus globales.
        /// </summary>
        /// <param name="valor">Valor logico que se desea asignar al permiso global.</param>
        /// <param name="pagina">La pagina donde se encuentra el componente Delta Grid.</param>        
        public void AsignarTodosLosEstatusGlobales(bool valor, Page pagina)
        {

            foreach (int permiso in Enum.GetValues(typeof(Enumerados.PERMISOS_GLOBALES)))
            {
                AsignarEstatusGlobales((Enumerados.PERMISOS_GLOBALES)permiso, valor, pagina);
            }
        }
        #endregion
    }


    #region Templates
    /// <summary>
    /// Clase que se usa para representar el componente en tiempo de diseño.
    /// </summary>
    public class PlantillaDisenio : System.Web.UI.Design.ControlDesigner
    {



        /// <summary>
        /// Inicializa el diseñador de controles y carga el componente especificado.
        /// </summary>
        /// <param name="component">El control que se va a diseñar.</param>
        public override void Initialize(IComponent component)
        {
            base.Initialize(component);

        }



        /// <summary>
        /// Recupera el formato HTML usado para representar el control en tiempo de diseño.
        /// </summary>
        /// <returns>El formato HTML que se utiliza para representar el control en tiempo de diseño.</returns>
        public override string GetDesignTimeHtml()
        {
            return "<br/><span style=\"color: #FFF;width:100px;height:100px;background: #A7C88E;font-family: 'Droid Sans', Arial, Helvetica, sans-serif;\">Edite el componente en la ficha de código</span>";
        }
    }

    #endregion
}
